package main

import (
	"fmt"
	"time"
)

// go 的变量 “名字 := 表达式”

/**
本节介绍 结构体 和 指针的形成

*/

type Employee struct {
	ID        int
	Name      string
	Address   string
	DoB       time.Time
	Position  string
	Salary    int
	ManagerID int
}

func main() {

	// 看起来真的很像就是 Employee是个类 然后dilbert是个对象
	var dilbert Employee
	// 然后对它的操作也是很像
	dilbert.Salary -= 5000

	fmt.Println(dilbert.Salary)

	// 初始化也很像
	type Point struct {
		X, Y int
	}
	p := Point{1, 2}

	fmt.Println(p)

	// 实现 链表  list：= &LinkedList{head: nil, length: 0}
	list := NewLinkedList()

	list.Append(10)
	list.Append(20)
	list.Append(30)
	list.Print() // 10 -> 20 -> 30 -> nil

	list.Prepend(5)
	list.Print() // 5 -> 10 -> 20 -> 30 -> nil

	list.InsertAt(15, 2)
	list.Print() // 5 -> 10 -> 15 -> 20 -> 30 -> nil

	list.RemoveAt(3)
	list.Print() // 5 -> 10 -> 15 -> 30 -> nil

	val, ok := list.Get(2)
	if ok {
		fmt.Println("Value at index 2:", val) // Value at index 2: 15
	} else {
		fmt.Println("Index out of range")
	}

	fmt.Println("Length of list:", list.Length()) // Length of list: 4

}

// Node 定义链表节点结构体
type Node struct {
	value int   // 节点存储的值
	next  *Node // 指向下一个节点的指针
}

// LinkedList 定义链表结构体，包含头节点指针和链表长度
type LinkedList struct {
	head   *Node // 链表头节点
	length int   // 链表长度
}

// NewLinkedList 创建并返回一个空链表
func NewLinkedList() *LinkedList {
	return &LinkedList{head: nil, length: 0}
}

// Append 在链表尾部添加一个新节点
func (l *LinkedList) Append(value int) {
	newNode := &Node{value: value, next: nil}
	if l.head == nil {
		// 如果链表为空，新节点作为头节点
		l.head = newNode
	} else {
		// 否则遍历到链表尾部，插入新节点
		current := l.head
		for current.next != nil {
			current = current.next
		}
		current.next = newNode
	}
	l.length++
}

// Prepend 在链表头部插入一个新节点
func (l *LinkedList) Prepend(value int) {
	newNode := &Node{value: value, next: l.head}
	l.head = newNode
	l.length++
}

// InsertAt 在指定位置插入新节点，位置从0开始
// 如果位置大于链表长度，则插入到尾部
func (l *LinkedList) InsertAt(value int, position int) {
	if position <= 0 {
		l.Prepend(value)
		return
	}
	if position >= l.length {
		l.Append(value)
		return
	}

	newNode := &Node{value: value}
	current := l.head
	for i := 0; i < position-1; i++ {
		current = current.next
	}
	newNode.next = current.next
	current.next = newNode
	l.length++
}

// RemoveAt 删除指定位置的节点，位置从0开始
// 如果位置无效，函数不做任何操作
func (l *LinkedList) RemoveAt(position int) {
	if position < 0 || position >= l.length || l.head == nil {
		return
	}
	if position == 0 {
		// 删除头节点
		l.head = l.head.next
		l.length--
		return
	}
	current := l.head
	for i := 0; i < position-1; i++ {
		current = current.next
	}
	// current.next 是要删除的节点
	current.next = current.next.next
	l.length--
}

// Get 返回指定位置节点的值，位置从0开始
// 如果位置无效，返回 -1 和 false
func (l *LinkedList) Get(position int) (int, bool) {
	if position < 0 || position >= l.length {
		return -1, false
	}
	current := l.head
	for i := 0; i < position; i++ {
		current = current.next
	}
	return current.value, true
}

// Print 打印链表所有节点的值
func (l *LinkedList) Print() {
	current := l.head
	for current != nil {
		fmt.Printf("%d -> ", current.value)
		current = current.next
	}
	fmt.Println("nil")
}

// Length 返回链表长度
func (l *LinkedList) Length() int {
	return l.length
}
